ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 335 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 416 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 462 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 516 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 617 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 665 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 221 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 267 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 354 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 532 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 632 A method invocation Binder.restoreCallingIdentity(callingId) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2072 A method invocation debugLog("IOException closing a file after writing the profile status") is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

OBJ09-J. Compare classes and not class names

There is no requirement that class names be unique, only that they are unique within a package. Therefore trying to determine an object's type based on its class name is an exercise fraught with danger. One of those dangers is that a malicious user will send objects of the same name as the trusted class and thereby gain trusted access.

In the given program line number 128 code block uuid.getClass().getName().equals("java.lang.String") trying to compare classes and not class names

This non-compliant code example compares the name of the class of object auth to the string "com.application.auth.DefaultAuthenticationHandler"

public class Demo {
   
  public Demo() {
	  //some code
  }
 
  public static void main(String[] args) {
	  Demo d=new Demo();
	  if (d.getClass().getName().equals(
		      "com.application.auth.DefaultAuthenticationHandler")) {
		   // ...
		}
  }
}

This compliant solution compares the class object auth to the class object for the canonical default authentication handler

public class Demo {
   
  public Demo() {
	  //some code
  }
 
  public static void main(String[] args) {
	  Demo d=new Demo();
	  if (d.getClass() == com.application.auth.DefaultAuthenticationHandler.class)
	   {
		   // ...
		}
  }
}

Additional information

• OBJ09-J. Compare classes and not class names

Related Guidelines

• CWE-486, Comparison of Classes by Name

EXP02-J. Do not use the Object.equals() method to compare two arrays

n Java, arrays are objects and support object methods such as Object.equals(). However, arrays do not support any methods besides those provided by Object. Consequently, using Object.equals() on any array compares only array references, not their contents. Programmers who wish to compare the contents of two arrays must use the static two-argument Arrays.equals() method. This method considers two arrays equivalent if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equivalent, according to Object.equals(). In other words, two arrays are equal if they contain equivalent elements in the same order. To test for reference equality, use the reference equality operators, == and !=. Because the effect of using Object.equals() to compare two arrays is often misconstrued as content equality, and because a better alternative exists in the use of reference equality operators, the use of the Object.equals() method to compare two arrays is disallowed.

In the given program line number 458 code block chan.mDevice.equals(device) trying to

This noncompliant code example uses the Object.equals() method to compare two arrays:

 
int[] arr1 = new int[20]; // Initialized to 0
int[] arr2 = new int[20]; // Initialized to 0
System.out.println(arr1.equals(arr2)); // Prints false
 

This compliant solution compares the content of two arrays using the two-argument Arrays.equals() method:

 
 
int[] arr1 = new int[20]; // Initialized to 0
int[] arr2 = new int[20]; // Initialized to 0
System.out.println(Arrays.equals(arr1, arr2)); // Prints true
 

Additional information

• EXP02-J. Do not use the Object.equals() method to compare two arrays

Related Guidelines

DCL00-J. Prevent class initialization cycles

Initialization of a class consists of executing its static initializers and the initializers for static fields (class variables) declared in the class. Therefore, the presence of a static field triggers the initialization of a class. However, the initializer of a static field could depend on the initialization of another class, possibly creating an initialization cycle.\cite{CERT}. There are two types of class initialization cycle problem, Intraclass and interclass. In intraclass the vulnerability happened because the constructor invocation is done before completing the initialization of the variables. The solution is, do the object creation after the complete variable initialization.

In the given program line number 758 have DCL00-J because chan.mDevice.equals(device) trying to

In the non-compliant code, there is a static final variable initialization after class object creation.

 
public class RollNo {
private final int idNumber;
private static final RollNo r= new RollNo();
private static final int seed = (int) (Math.random() * 100);
public RollNo() {
idNumber = seed - 10;
}
public static void main(String[] args) {
System.out.println("Your unique id is: " + r.idNumber);
}
}
 

In the compliant code, the static final variable initialization done before class object creation.

 
public class RollNo {
private final int idNumber;
private static final int seed = (int) (Math.random() * 100);
private static final RollNo r= new RollNo();
public RollNo() {
idNumber = seed - 10;
}
public static void main(String[] args) {
System.out.println("Your unique id is: " + r.idNumber);
}
}
 

Additional information

• DCL00-J. Prevent class initialization cycles

Related Guidelines

• DCL14-CPP. Avoid assumptions about the initialization order between translation units
• CWE-665, Improper Initialization

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 186 A method invocation mProviderClient.release() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 41 code block public static int INVALID_VALUE=-1; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1070 A method invocation contacts.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1139 A method invocation contacts.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1214 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1314 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1348 A method invocation cr.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1376 A method invocation cr.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1403 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2263 A method invocation imCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2296 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2310 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2326 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2344 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2380 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2396 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2415 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2435 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2676 A method invocation smsMmsCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2764 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2861 A method invocation imEmailCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3345 A method invocation close(p) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3366 A method invocation close(q) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3443 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3487 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3519 A method invocation close(is) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3599 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3667 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3725 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3871 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3831 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 3856 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3988 A method invocation contacts.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1164 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1188 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1215 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1263 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1406 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1562 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1719 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1984 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2124 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2174 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2207 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2251 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 2445 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2556 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2659 A method invocation queryResult.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2734 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3063 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3238 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 3263 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 164 A method invocation xmlDocument.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 330 A method invocation xmlDocument.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 284 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 525 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 756 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 21 code block public static HashMap mCheckedChilds=new HashMap(); trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 51 code block public static int SMS_TYPE_GSM=1; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 52 code block public static int SMS_TYPE_CDMA=2; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

MSC02-J. Generate strong random numbers

When software generates predictable values in a context requiring unpredictability, it may be possible for an attacker to guess the next value that will be generated, and use this guess to impersonate another user or access sensitive information. As the java.util.Random class relies on a pseudorandom number generator, this class and relating java.lang.Math.random() method should not be used for security-critical applications or for protecting sensitive data. In such context, the java.security.SecureRandom class which relies on a cryptographically strong random number generator (RNG) should be used in place.

In the given program line number 471 code block new Random() trying to

This noncompliant code example uses the insecure java.util.Random class. This class produces an identical sequence of numbers for each given seed value; consequently, the sequence of numbers is predictable.

 
 
import java.util.Random;
// ...
 
Random number = new Random(123L);
//...
for (int i = 0; i < 20; i++) {
  // Generate another random integer in the range [0, 20]
  int n = number.nextInt(21);
  System.out.println(n);
}
 

This compliant solution uses the java.security.SecureRandom class to produce high-quality random numbers:

 
 
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
// ...
 
public static void main (String args[]) {
  SecureRandom number = new SecureRandom();
  // Generate 20 integers 0..20
  for (int i = 0; i < 20; i++) {
    System.out.println(number.nextInt(21));
  }
}
 

Additional information

• MSC02-J. Generate strong random numbers

Related Guidelines

• CVE-2006-6969

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 386 A method invocation e.getMessage() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 89 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 133 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 191 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 106 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 337 A method invocation e.printStackTrace() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR02-J. Prevent exceptions while logging data

When logging a message there are several important requirements which must be fulfilled:

• The user must be able to easily retrieve the logs
• The format of all logged message must be uniform to allow the user to easily read the log
• Logged data must actually be recorded
• Sensitive data must only be logged securely

In the given program line number 326 code block e.printStackTrace() trying to

his noncompliant code example writes a critical security exception to the standard error stream.Writing such exceptions to the standard error stream is inadequate for logging purposes. First, the standard error stream may be exhausted or closed, preventing recording of subsequent exceptions. Second, the trust level of the standard error stream may be insufficient for recording certain security-critical exceptions or errors without leaking sensitive information. If an I/O error were to occur while writing the security exception, the catch block would throw an IOException and the critical security exception would be lost. Finally, an attacker may disguise the exception so that it occurs with several other innocuous exceptions. Using Console.printf(), System.out.print*(), or Throwable.printStackTrace() to output a security exception also constitutes a violation of this rule.

 
try {
  // ...
} catch (SecurityException se) {
  System.err.println(se);
  // Recover from exception
}
 

This compliant solution uses java.util.logging.Logger, the default logging API provided by JDK 1.4 and later. Use of other compliant logging mechanisms, such as log4j, is also permitted.

 try {
  // ...
} catch(SecurityException se) {
  logger.log(Level.SEVERE, se);
  // Recover from exception
}

Additional information

• ERR02-J. Prevent exceptions while logging data

Related Guidelines

• HARMONY-5981

ERR02-J. Prevent exceptions while logging data

When logging a message there are several important requirements which must be fulfilled:

• The user must be able to easily retrieve the logs
• The format of all logged message must be uniform to allow the user to easily read the log
• Logged data must actually be recorded
• Sensitive data must only be logged securely

In the given program line number 337 code block e.printStackTrace() trying to

his noncompliant code example writes a critical security exception to the standard error stream.Writing such exceptions to the standard error stream is inadequate for logging purposes. First, the standard error stream may be exhausted or closed, preventing recording of subsequent exceptions. Second, the trust level of the standard error stream may be insufficient for recording certain security-critical exceptions or errors without leaking sensitive information. If an I/O error were to occur while writing the security exception, the catch block would throw an IOException and the critical security exception would be lost. Finally, an attacker may disguise the exception so that it occurs with several other innocuous exceptions. Using Console.printf(), System.out.print*(), or Throwable.printStackTrace() to output a security exception also constitutes a violation of this rule.

 
try {
  // ...
} catch (SecurityException se) {
  System.err.println(se);
  // Recover from exception
}
 

This compliant solution uses java.util.logging.Logger, the default logging API provided by JDK 1.4 and later. Use of other compliant logging mechanisms, such as log4j, is also permitted.

 try {
  // ...
} catch(SecurityException se) {
  logger.log(Level.SEVERE, se);
  // Recover from exception
}

Additional information

• ERR02-J. Prevent exceptions while logging data

Related Guidelines

• HARMONY-5981

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 499 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 107 A method invocation metadataCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

MSC02-J. Generate strong random numbers

When software generates predictable values in a context requiring unpredictability, it may be possible for an attacker to guess the next value that will be generated, and use this guess to impersonate another user or access sensitive information. As the java.util.Random class relies on a pseudorandom number generator, this class and relating java.lang.Math.random() method should not be used for security-critical applications or for protecting sensitive data. In such context, the java.security.SecureRandom class which relies on a cryptographically strong random number generator (RNG) should be used in place.

In the given program line number 229 code block new Random(SystemClock.uptimeMillis()) trying to

This noncompliant code example uses the insecure java.util.Random class. This class produces an identical sequence of numbers for each given seed value; consequently, the sequence of numbers is predictable.

 
 
import java.util.Random;
// ...
 
Random number = new Random(123L);
//...
for (int i = 0; i < 20; i++) {
  // Generate another random integer in the range [0, 20]
  int n = number.nextInt(21);
  System.out.println(n);
}
 

This compliant solution uses the java.security.SecureRandom class to produce high-quality random numbers:

 
 
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
// ...
 
public static void main (String args[]) {
  SecureRandom number = new SecureRandom();
  // Generate 20 integers 0..20
  for (int i = 0; i < 20; i++) {
    System.out.println(number.nextInt(21));
  }
}
 

Additional information

• MSC02-J. Generate strong random numbers

Related Guidelines

• CVE-2006-6969

MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Programs must use the javax.net.ssl.SSLSocket class rather than the java.net.Socket class when transferring sensitive data over insecure communication channels. The class SSLSocket provides security protocols such as Secure Sockets Layer/Transport Layer Security (SSL/TLS) to ensure that the channel is not vulnerable to eavesdropping and malicious tampering.

In the given program line number 88 code block Use SSLSocket rather than Socket use SSLSocket rather than Socket for secure data exchange

This noncompliant code example shows the use of regular sockets for a server application that fails to protect sensitive information in transit. The insecure code for the corresponding client application follows the server's code.

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket(9999);
      Socket socket = serverSocket.accept();
      PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(socket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (serverSocket != null) {
        try {
          serverSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 
 

This compliant solution uses SSLSocket to protect packets using the SSL/TLS security protocols:

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    SSLServerSocket sslServerSocket = null;
    try {
      SSLServerSocketFactory sslServerSocketFactory =
          (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
      sslServerSocket = (SSLServerSocket) sslServerSocketFactory.
                        createServerSocket(9999);
      SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
      PrintWriter out = new PrintWriter(sslSocket.getOutputStream(),true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(sslSocket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (sslServerSocket != null) {
        try {
          sslServerSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 

Additional information

• MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Related Guidelines

• CWE-311, Failure to Encrypt Sensitive Data

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 129 A method invocation metadataCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1014 A method invocation mConnection.disconnect() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Programs must use the javax.net.ssl.SSLSocket class rather than the java.net.Socket class when transferring sensitive data over insecure communication channels. The class SSLSocket provides security protocols such as Secure Sockets Layer/Transport Layer Security (SSL/TLS) to ensure that the channel is not vulnerable to eavesdropping and malicious tampering.

In the given program line number 567 code block Use SSLSocket rather than Socket use SSLSocket rather than Socket for secure data exchange

This noncompliant code example shows the use of regular sockets for a server application that fails to protect sensitive information in transit. The insecure code for the corresponding client application follows the server's code.

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket(9999);
      Socket socket = serverSocket.accept();
      PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(socket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (serverSocket != null) {
        try {
          serverSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 
 

This compliant solution uses SSLSocket to protect packets using the SSL/TLS security protocols:

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    SSLServerSocket sslServerSocket = null;
    try {
      SSLServerSocketFactory sslServerSocketFactory =
          (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
      sslServerSocket = (SSLServerSocket) sslServerSocketFactory.
                        createServerSocket(9999);
      SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
      PrintWriter out = new PrintWriter(sslSocket.getOutputStream(),true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(sslSocket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (sslServerSocket != null) {
        try {
          sslServerSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 

Additional information

• MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Related Guidelines

• CWE-311, Failure to Encrypt Sensitive Data

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 275 code block public static String filename_SEQUENCE_SEPARATOR="-"; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Programs must use the javax.net.ssl.SSLSocket class rather than the java.net.Socket class when transferring sensitive data over insecure communication channels. The class SSLSocket provides security protocols such as Secure Sockets Layer/Transport Layer Security (SSL/TLS) to ensure that the channel is not vulnerable to eavesdropping and malicious tampering.

In the given program line number 394 code block Use SSLSocket rather than Socket use SSLSocket rather than Socket for secure data exchange

This noncompliant code example shows the use of regular sockets for a server application that fails to protect sensitive information in transit. The insecure code for the corresponding client application follows the server's code.

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket(9999);
      Socket socket = serverSocket.accept();
      PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(socket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (serverSocket != null) {
        try {
          serverSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 
 

This compliant solution uses SSLSocket to protect packets using the SSL/TLS security protocols:

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    SSLServerSocket sslServerSocket = null;
    try {
      SSLServerSocketFactory sslServerSocketFactory =
          (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
      sslServerSocket = (SSLServerSocket) sslServerSocketFactory.
                        createServerSocket(9999);
      SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
      PrintWriter out = new PrintWriter(sslSocket.getOutputStream(),true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(sslSocket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (sslServerSocket != null) {
        try {
          sslServerSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 

Additional information

• MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Related Guidelines

• CWE-311, Failure to Encrypt Sensitive Data

ERR02-J. Prevent exceptions while logging data

When logging a message there are several important requirements which must be fulfilled:

• The user must be able to easily retrieve the logs
• The format of all logged message must be uniform to allow the user to easily read the log
• Logged data must actually be recorded
• Sensitive data must only be logged securely

In the given program line number 527 code block e.printStackTrace() trying to

his noncompliant code example writes a critical security exception to the standard error stream.Writing such exceptions to the standard error stream is inadequate for logging purposes. First, the standard error stream may be exhausted or closed, preventing recording of subsequent exceptions. Second, the trust level of the standard error stream may be insufficient for recording certain security-critical exceptions or errors without leaking sensitive information. If an I/O error were to occur while writing the security exception, the catch block would throw an IOException and the critical security exception would be lost. Finally, an attacker may disguise the exception so that it occurs with several other innocuous exceptions. Using Console.printf(), System.out.print*(), or Throwable.printStackTrace() to output a security exception also constitutes a violation of this rule.

 
try {
  // ...
} catch (SecurityException se) {
  System.err.println(se);
  // Recover from exception
}
 

This compliant solution uses java.util.logging.Logger, the default logging API provided by JDK 1.4 and later. Use of other compliant logging mechanisms, such as log4j, is also permitted.

 try {
  // ...
} catch(SecurityException se) {
  logger.log(Level.SEVERE, se);
  // Recover from exception
}

Additional information

• ERR02-J. Prevent exceptions while logging data

Related Guidelines

• HARMONY-5981

ERR02-J. Prevent exceptions while logging data

When logging a message there are several important requirements which must be fulfilled:

• The user must be able to easily retrieve the logs
• The format of all logged message must be uniform to allow the user to easily read the log
• Logged data must actually be recorded
• Sensitive data must only be logged securely

In the given program line number 524 code block e1.printStackTrace() trying to

his noncompliant code example writes a critical security exception to the standard error stream.Writing such exceptions to the standard error stream is inadequate for logging purposes. First, the standard error stream may be exhausted or closed, preventing recording of subsequent exceptions. Second, the trust level of the standard error stream may be insufficient for recording certain security-critical exceptions or errors without leaking sensitive information. If an I/O error were to occur while writing the security exception, the catch block would throw an IOException and the critical security exception would be lost. Finally, an attacker may disguise the exception so that it occurs with several other innocuous exceptions. Using Console.printf(), System.out.print*(), or Throwable.printStackTrace() to output a security exception also constitutes a violation of this rule.

 
try {
  // ...
} catch (SecurityException se) {
  System.err.println(se);
  // Recover from exception
}
 

This compliant solution uses java.util.logging.Logger, the default logging API provided by JDK 1.4 and later. Use of other compliant logging mechanisms, such as log4j, is also permitted.

 try {
  // ...
} catch(SecurityException se) {
  logger.log(Level.SEVERE, se);
  // Recover from exception
}

Additional information

• ERR02-J. Prevent exceptions while logging data

Related Guidelines

• HARMONY-5981

MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Programs must use the javax.net.ssl.SSLSocket class rather than the java.net.Socket class when transferring sensitive data over insecure communication channels. The class SSLSocket provides security protocols such as Secure Sockets Layer/Transport Layer Security (SSL/TLS) to ensure that the channel is not vulnerable to eavesdropping and malicious tampering.

In the given program line number 568 code block Use SSLSocket rather than Socket use SSLSocket rather than Socket for secure data exchange

This noncompliant code example shows the use of regular sockets for a server application that fails to protect sensitive information in transit. The insecure code for the corresponding client application follows the server's code.

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket(9999);
      Socket socket = serverSocket.accept();
      PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(socket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (serverSocket != null) {
        try {
          serverSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 
 

This compliant solution uses SSLSocket to protect packets using the SSL/TLS security protocols:

 
class EchoServer {
  public static void main(String[] args) throws IOException {
    SSLServerSocket sslServerSocket = null;
    try {
      SSLServerSocketFactory sslServerSocketFactory =
          (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
      sslServerSocket = (SSLServerSocket) sslServerSocketFactory.
                        createServerSocket(9999);
      SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
      PrintWriter out = new PrintWriter(sslSocket.getOutputStream(),true);
      BufferedReader in = new BufferedReader(
          new InputStreamReader(sslSocket.getInputStream()));
      String inputLine;
      while ((inputLine = in.readLine()) != null) {
        System.out.println(inputLine);
        out.println(inputLine);
      }
    } finally {
      if (sslServerSocket != null) {
        try {
          sslServerSocket.close();
        } catch (IOException x) {
          // Handle error
        }
      }
    }
  }
}
 

Additional information

• MSC00-J. Use SSLSocket rather than Socket for secure data exchange

Related Guidelines

• CWE-311, Failure to Encrypt Sensitive Data

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 132 A method invocation mCursor.moveToNext() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 156 code block public static int ORDER_BY_INDEXED=0; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 158 code block public static int ORDER_BY_ALPHABETICAL=1; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 160 code block public static boolean sIsAborted=false; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 709 A method invocation closeStream(outputStream,op) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 51 code block public static int FILTER_PHOTO=3; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 52 code block public static int FILTER_TEL=7; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 53 code block public static int FILTER_NICKNAME=23; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 178 A method invocation contactCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 199 A method invocation callCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 242 A method invocation callCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 283 A method invocation contactCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 325 A method invocation contactCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 377 A method invocation callsCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 428 A method invocation contactCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 458 A method invocation contactCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 606 A method invocation buffer.onTerminate() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 661 A method invocation buffer.onTerminate() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 474 A method invocation msg.sendToTarget() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 410 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 528 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 557 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 588 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 617 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 640 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 655 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 222 A method invocation Binder.restoreCallingIdentity(ident) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 256 A method invocation Binder.restoreCallingIdentity(ident) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 51 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1151 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 93 A method invocation connection.disconnect() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 154 A method invocation connection.disconnect() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 75 A method invocation cleanup() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 144 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

DCL00-J. Prevent class initialization cycles

Initialization of a class consists of executing its static initializers and the initializers for static fields (class variables) declared in the class. Therefore, the presence of a static field triggers the initialization of a class. However, the initializer of a static field could depend on the initialization of another class, possibly creating an initialization cycle.\cite{CERT}. There are two types of class initialization cycle problem, Intraclass and interclass. In intraclass the vulnerability happened because the constructor invocation is done before completing the initialization of the variables. The solution is, do the object creation after the complete variable initialization.

In the given program line number 165 have DCL00-J because t.assignLoop("files",new ListEntityIterator(){ int index=-1; @Override public void writeValue( OutputStream stream, String key) throws IOException { File f=files[index]; if ("name".equals(key)) { stream.write(f.getName().getBytes()); } if ("url".equals(key)) { stream.write(("file://" + f.getAbsolutePath()).getBytes()); } if ("type".equals(key)) { stream.write((f.isDirectory() ? "dir" : "file").getBytes()); } if ("size".equals(key)) { if (f.isFile()) { stream.write(readableFileSize(f.length()).getBytes()); } } if ("last_modified".equals(key)) { String date=DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT).format(f.lastModified()); stream.write(date.getBytes()); } if ("alt".equals(key)) { if (index % 2 == 0) { stream.write("alt".getBytes()); } } } @Override public ListEntityIterator getListIterator( String key){ return null; } @Override public void reset(){ index=-1; } @Override public boolean moveToNext(){ return (++index) < files.length; } } ) trying to

In the non-compliant code, there is a static final variable initialization after class object creation.

 
public class RollNo {
private final int idNumber;
private static final RollNo r= new RollNo();
private static final int seed = (int) (Math.random() * 100);
public RollNo() {
idNumber = seed - 10;
}
public static void main(String[] args) {
System.out.println("Your unique id is: " + r.idNumber);
}
}
 

In the compliant code, the static final variable initialization done before class object creation.

 
public class RollNo {
private final int idNumber;
private static final int seed = (int) (Math.random() * 100);
private static final RollNo r= new RollNo();
public RollNo() {
idNumber = seed - 10;
}
public static void main(String[] args) {
System.out.println("Your unique id is: " + r.idNumber);
}
}
 

Additional information

• DCL00-J. Prevent class initialization cycles

Related Guidelines

• DCL14-CPP. Avoid assumptions about the initialization order between translation units
• CWE-665, Improper Initialization

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 78 A method invocation in.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 161 A method invocation tmpfile.delete() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 150 A method invocation in.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 161 code block tmpfile.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 203 A method invocation out.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 220 A method invocation out.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 638 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 278 A method invocation cur.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 105 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 159 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 166 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 129 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 206 A method invocation searchClientIdCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 363 code block gearsFiles[i].delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 381 code block files[i].delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 381 code block files[i].delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 441 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 581 A method invocation helper.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 711 A method invocation preloads.recycle() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 730 A method invocation is.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 749 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1264 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1412 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1566 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1638 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1663 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1855 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1870 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1984 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2050 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 131 code block oldPath.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 131 code block oldPath.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 131 code block oldPath.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 118 A method invocation mDb.endTransaction() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 141 A method invocation mDb.endTransaction() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 161 A method invocation mDb.endTransaction() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 184 A method invocation mDb.endTransaction() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 230 A method invocation onEndTransaction(callerIsSyncAdapter) is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 20 code block public static NullController INSTANCE=new NullController(); trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

SER05-J. Do not serialize instances of inner classes

"An inner class is a nested class that is not explicitly or implicitly declared static". Serialization of inner classes (including local and anonymous classes) is error prone.

In the given program line number 239 code block ' Outer class name 'TabBar' Inner class name 'TabView' Instances name[OnClickListener] trying to serialize instances of inner classes

In this noncompliant code example, the fields contained within the outer class are serialized when the inner class is serialized:

 
 public class OuterSer implements Serializable {
  private int rank;
  class InnerSer implements Serializable {
    protected String name;
    // ...
  }
}
 

The InnerSer class of this compliant solution deliberately fails to implement the Serializable interface:

 
 public class OuterSer implements Serializable {
  private int rank;
  class InnerSer {
    protected String name;
    // ...
  }
}
 

Additional information

• SER05-J. Do not serialize instances of inner classes

Related Guidelines

• CWE-499, Serializable Class Containing Sensitive Data

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 37 code block public static enum ComboViews; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 2076 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 95 code block state.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 246 A method invocation p.recycle() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 240 code block stateFile.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 240 code block stateFile.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 240 code block stateFile.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

FIO02-J. Detect and handle file-related errors

Java's file-manipulation methods often indicate failure with a return value instead of throwing an exception. Consequently, programs that ignore the return values from file operations often fail to detect that those operations have failed. Java programs must check the return values of methods that perform file I/O.

In the given program line number 240 code block stateFile.delete(); trying to delete file without detect and handle file-related errors

This noncompliant code example attempts to delete a specified file but gives no indication of its success.

 
 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
	file.delete();
}
	}
	
 

This compliant solution checks the return value of delete()

 class FileDelete {
	public static void main(String args[]){
		File file = new File("file");
if (!file.delete()) {
  System.out.println("Deletion failed");
}
	}

Additional information

• FIO02-J. Detect and handle file-related errors

Related Guidelines

• FIO04-CPP. Detect and handle input and output errors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 238 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 267 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 286 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 133 A method invocation connection.disconnect() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 122 A method invocation instancesCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 274 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 640 A method invocation eventCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 664 A method invocation attendeesCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 692 A method invocation eventCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 719 A method invocation attendeesCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 830 A method invocation alertCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 1081 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 325 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 437 A method invocation eventCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 471 A method invocation calendarCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 514 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 208 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 237 A method invocation eventCursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

OBJ10-J. Do not use public static nonfinal fields

There is no good reason to declare a field "public" and "static" without also declaring it "final". Most of the time this is a kludge to share a state among several objects. But with this approach, any object can do whatever it wants with the shared state, such as setting it to null.

In the given program line number 72 code block public static int LIST_TOP_OFFSET=-1; trying to use public static nonfinal fields

This non-compliant declares a function table containing a public static field.

 
 public class Greeter {
  public static Foo foo = new Foo();
  ...
}
 

This compliant solution declares the FuncLoader static field final and treats it as a constant:

 
 public class Greeter {
  public static final Foo FOO = new Foo();
  ...
}
 

Additional information

• OBJ10-J. Do not use public static nonfinal fields

Related Guidelines

• MITRE, CWE-500 - Public Static Field Not Marked Final
• CERT OBJ10-J - Do not use public static nonfinal fields

ERR08-J. Do not catch NullPointerException or any of its ancestors

NullPointerException should be avoided, not caught. Any situation in which NullPointerException is explicitly caught can easily be converted to a null test, and any behavior being carried out in the catch block can easily be moved to the "is null" branch of the conditional.

In the given program line number 176 catch block contains a null pointer exception NullPointerException e

In the Non-compliant Solution rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.

 
public int lengthPlus(String str) {
  int len = 2;
  try {
    len += str.length();
  }
  catch (NullPointerException e) {
    log.info("argument was null");
  }
  return len;
}
 

This compliant solution explicitly checks the String argument for null rather than catching NullPointerException:

 
 public int lengthPlus(String str) {
  int len = 2;

  if (str != null) {
    len += str.length();
  }
  else {
    log.info("argument was null");
  }
  return len;
}

Additional information

• ERR08-J. Do not catch NullPointerException or any of its ancestors

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 505 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 466 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 302 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 322 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 344 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 735 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 739 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 414 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 444 A method invocation c.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 283 A method invocation Debug.stopMethodTracing() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

ERR05-J. Do not let checked exceptions escape from a finally block

Methods invoked from within a finally block can throw an exception. Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. Abrupt termination causes any exception thrown in the try block to be lost, preventing any possible recovery method from handling that specific problem.

In the given program line number 113 A method invocation cursor.close() is present inside a finally block without a try-catch block

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions and consequently fails to appropriately handle any exception that may arise.

 
 try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        reader.close();
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
 

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, the potential IOException can be handled without allowing it to propagate further.t

 
  try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      try {
        // Do operations
      } finally {
        try {
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
        // ... Other cleanup code ...
      }
    } catch (IOException x) {
      // Forward to handler
    }
    

Additional information

• ERR05-J. Do not let checked exceptions escape from a finally block

Related Guidelines

• CWE-703, Improper Check or Handling of Exceptional Conditions
• CWE-248, Uncaught Exception

DCL02-J. Do not modify the collection's elements during an enhanced for statement

Unlike the basic for statement, assignments to the loop variable fail to affect the loop's iteration order over the underlying set of objects. Consequently, an assignment to the loop variable is equivalent to modifying a variable local to the loop body whose initial value is the object referenced by the loop iterator. This modification is not necessarily erroneous but can obscure the loop functionality or indicate a misunderstanding of the underlying implementation of the enhanced for statement. Declare all enhanced for statement loop variables final. The final declaration causes Java compilers to flag and reject any assignments made to the loop variable.

In the given program line number 350 code block contains email trying to modify the collection's elements during an enhanced for statement

This noncompliant code example attempts to process a collection of integers using an enhanced for loop. It further intends to modify one item in the collection for processing:

 
List list = Arrays.asList(new Integer[] {13, 14, 15});
boolean first = true;
 
System.out.println("Processing list...");
for (Integer i: list) {
  if (first) {
    first = false;
    i = new Integer(99);
  }
  System.out.println(" New item: " + i);
  // Process i
}
 
System.out.println("Modified list?");
for (Integer i: list) {
  System.out.println("List item: " + i);
}
 

This compliant solution processes the "modified" list but leaves the actual list unchanged:

 
// ...
 
for (final Integer i: list) {
  Integer item = i;
  if (first) {
    first = false;
    item = new Integer(99);
  }
  System.out.println(" New item: " + item);
  // Process item
}
 
// ...
 

Additional information

• DCL02-J. Do not modify the collection's elements during an enhanced for statement

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 32 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 213 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 248 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}
 

This compliant solution throws NullPointerException to denote the specific exceptional condition

  boolean isCapitalized(String s) {
  if (s == null) {
    throw new NullPointerException();
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}

Additional information

• ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Related Guidelines

• CWE-397, Declaration of Throws for Generic Exception

ERR07-J. Do not throw RuntimeException, Exception, or Throwable

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

Methods must not throw RuntimeException, Exception, or Throwable. Throwing a RuntimeException can lead to subtle errors; for example, a caller cannot examine the exception to determine why it was thrown and consequently cannot attempt recovery.

In the given program line number 119 throws RuntimeException

The isCapitalized() method in this noncompliant code example accepts a string and returns true when the string consists of a capital letter followed by lowercase letters. The method also throws a RuntimeException when passed a null string argument.

 
boolean isCapitalized(String s) {
  if (s == null) {
    throw new RuntimeException("Null String");
  }
  if (s.equals("")) {
    return true;
  }
  String first = s.substring(0, 1);
  String rest = s.substring(1);
  return (first.equals(first.toUpperCase()) &&
          rest.equals(rest.toLowerCase()));
}